{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pandas_datareader import data as datareader\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from datetime import timedelta\n",
    "import shap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# tickers = ['SPX', 'IBM', 'TSLA', 'OIL', 'MSFT', 'AAPL', 'AMZN']\n",
    "tickers = ['AAPL']\n",
    "\n",
    "start_date = '2000-01-01'\n",
    "end_date = '2020-01-01'\n",
    "\n",
    "datasets = {}\n",
    "for ticker in tickers:\n",
    "    data = datareader.DataReader(ticker, 'yahoo', start_date, end_date)\n",
    "    datasets[ticker] = data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Feature extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ! pip3.6 install --upgrade mlfinlab&nstall numba\n",
    "# ! pip3.6 install TA-Lib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mlfinlab.features.fracdiff import frac_diff_ffd\n",
    "from utils import get_meta_barier, getDailyVol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import talib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "% matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "WINDOW = 14\n",
    "HORIZON = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = datasets[tickers[0]]\n",
    "data.columns = [c.lower() for c in data.columns]\n",
    "frac_diff_series = frac_diff_ffd(pd.DataFrame(data['close']), 0.5, thresh=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5031, 1), (5031, 6))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frac_diff_series.shape, data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(data.close)\n",
    "plt.plot(frac_diff_series)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['feat_mean_frac_close'] = frac_diff_series.rolling(WINDOW).mean()\n",
    "data['feat_std_frac_close'] = frac_diff_series.rolling(WINDOW).std()\n",
    "data['feat_skew_frac_close'] = frac_diff_series.rolling(WINDOW).skew()\n",
    "data['feat_kurt_frac_close'] = frac_diff_series.rolling(WINDOW).kurt()\n",
    "data['feat_autocorr_frac_close'] = frac_diff_series.rolling(WINDOW).apply(lambda x: x.autocorr(), raw=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data['feat_RSI_close'] = talib.RSI(data.close)\n",
    "data['feat_OBV_volume'] = talib.OBV(data.close, data.volume)\n",
    "data['feat_ATR_close'] = talib.ATR(data.high, data.low, data.close, WINDOW)\n",
    "data['feat_HT_DCPERIOD_close'] = talib.HT_DCPERIOD(data.close)\n",
    "data['feat_HT_DCPHASE_close'] = talib.HT_DCPHASE(data.close)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['feat_random1'] = np.random.normal(0, 1, size=(data.shape[0]))\n",
    "data['feat_random2'] = np.random.uniform(0, 1, size=(data.shape[0]))\n",
    "data['feat_random3'] = np.random.poisson(1, size=(data.shape[0]))\n",
    "data['feat_random4'] = np.random.binomial(1, 0.5, size=(data.shape[0]))\n",
    "data['feat_random5'] = np.random.logistic(0, 1, size=(data.shape[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "FEATURE_COLUMNS = [d for d in data.columns if 'feat_' in d]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "daily_vol = getDailyVol(data.close)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def create_dataset(data, daily_vol):\n",
    "    \n",
    "    TP = 0.01\n",
    "    SL = - TP\n",
    "\n",
    "    T, P, X, Y, Y2 = [], [], [], [], []\n",
    "    TIME = []\n",
    "    \n",
    "    for i in daily_vol.index:\n",
    "\n",
    "        window = data.loc[i][FEATURE_COLUMNS].values\n",
    "\n",
    "        if np.isnan(window).any():\n",
    "            continue\n",
    "\n",
    "        now = data.close[i]\n",
    "        future_window = data.loc[i:i + timedelta(days=HORIZON)].close\n",
    "\n",
    "        Ti = daily_vol.loc[i]\n",
    "\n",
    "        min_ret_situation, take_action, timings = get_meta_barier(future_window, now, Ti, TP, SL, False)\n",
    "\n",
    "        X.append(window)\n",
    "        Y.append(min_ret_situation)\n",
    "        Y2.append(take_action)\n",
    "        T.append(timings)\n",
    "        P.append(data.loc[i].close)\n",
    "        TIME.append(i)\n",
    "        \n",
    "    dataset_df = pd.DataFrame(np.array(X), columns = [FEATURE_COLUMNS], index = TIME)\n",
    "    dataset_df['bin'] = np.argmax(Y, axis=1)\n",
    "    dataset_df['t1'] = pd.Series(dataset_df.index, index = dataset_df.index)\n",
    "    dataset_df['w'] = 1. / len(Y)\n",
    "\n",
    "    X = dataset_df[FEATURE_COLUMNS]\n",
    "    Y = pd.Series(dataset_df['bin'].values.flatten().tolist(), index=X.index).to_frame('bin')\n",
    "    Y['w'] = 1./Y.shape[0]\n",
    "    Y['t1'] = pd.Series(Y.index, index = Y.index)\n",
    "    X.columns = FEATURE_COLUMNS\n",
    "    \n",
    "    return X, Y, T, P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = datetime.strptime('2010-01-01', '%Y-%m-%d') # 2017"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "X, Y, T, P = create_dataset(data[:t], daily_vol[:t])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "X_oos, Y_oos, T_oos, P_oos = create_dataset(data[t:], daily_vol[t:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Feature Importance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "from sklearn.metrics import log_loss, accuracy_score\n",
    "from sklearn import model_selection\n",
    "\n",
    "from scipy.cluster.hierarchy import linkage, fcluster\n",
    "from itertools import product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MYw5XNhK1T26"
   },
   "outputs": [],
   "source": [
    "def featImpMDI(fit, featNames):\n",
    "    # feat importance based on IS mean impurity reduction\n",
    "    df0 = {i:tree.feature_importances_ for i, tree in enumerate(fit.estimators_)}\n",
    "    \n",
    "    \n",
    "    df0 = pd.DataFrame.from_dict(df0, orient='index')\n",
    "    df0.columns = featNames\n",
    "\n",
    "    df0 = df0.replace(0, np.nan) # because max_features=1\n",
    "    imp = pd.concat({'mean': df0.mean(), 'std': df0.std() * df0.shape[0] ** -.5}, axis=1)\n",
    "    imp /= imp['mean'].sum()\n",
    "\n",
    "    return imp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jp4sXxbG1oDm"
   },
   "outputs": [],
   "source": [
    "def featImpMDA(clf, X, y, cv, sample_weight, t1, pctEmbargo, scoring='accuracy'):\n",
    "    # feat importance based on OOS score reduction\n",
    "    if scoring not in ['neg_log_loss','accuracy']:\n",
    "        raise Exception('wrong scoring method.')\n",
    "\n",
    "    cvGen=PurgedKFold(n_splits=cv,t1=t1,pctEmbargo=pctEmbargo) # purged cv\n",
    "    scr0,scr1=pd.Series(),pd.DataFrame(columns=X.columns)\n",
    "\n",
    "    for i,(train,test) in enumerate(cvGen.split(X=X)):\n",
    "        \n",
    "        X0,y0,w0=X.iloc[train,:],y.iloc[train],sample_weight.iloc[train]\n",
    "        X1,y1,w1=X.iloc[test,:],y.iloc[test],sample_weight.iloc[test]\n",
    "        fit=clf.fit(X=X0,y=y0,sample_weight=w0.values)\n",
    "        pred=fit.predict(X1)\n",
    "        scr0.loc[i]=accuracy_score(y1,pred,sample_weight=w1.values)\n",
    "        for j in X.columns:\n",
    "\n",
    "            X1_=X1.copy(deep=True)\n",
    "            np.random.shuffle(X1_[j].values) # permutation of a single column\n",
    "\n",
    "            pred=fit.predict(X1_)\n",
    "            scr1.loc[i,j]=accuracy_score(y1,pred,sample_weight=w1.values)\n",
    "\n",
    "    imp=(-scr1).add(scr0,axis=0)\n",
    "    imp=imp/(1.-scr1)\n",
    "    imp=pd.concat({'mean':imp.mean(),'std':imp.std()*imp.shape[0]**-.5},axis=1)\n",
    "    return imp,scr0.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MRQIjb2x1ph2"
   },
   "outputs": [],
   "source": [
    "def auxFeatImpSFI(featNames, clf, trnsX, cont, scoring, cvGen):\n",
    "    imp = pd.DataFrame(columns=['mean','std'])\n",
    "    for featName in featNames:\n",
    "        df0 = cvScore(clf, X=trnsX[[featName]], y=cont['bin'], sample_weight=cont['w'], scoring=scoring, cvGen=cvGen)\n",
    "        imp.loc[featName,'mean'] = df0.mean()\n",
    "        imp.loc[featName,'std'] = df0.std()*df0.shape[0]**-.5\n",
    "    return imp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def feat_imp_CFI_MDA(X, y, cv, sample_weight, t1, pctEmbargo = 0, scoring='accuracy', \n",
    "                     C = 2, minWLeaf = 0.0, max_samples = 1.0, n_estimators = 10):\n",
    "\n",
    "    def correlDist(corr):\n",
    "      # A distance matrix based on correlation, where 0<=d[i,j]<=1\n",
    "      # This is a proper distance metric\n",
    "      dist = ((1 - corr) / 2.)**.5  # distance matrix\n",
    "      return dist\n",
    "\n",
    "    def cluster_features():\n",
    "        dist_matrix = correlDist(X.corr())\n",
    "        link = linkage(dist_matrix, 'single')\n",
    "        clusters = fcluster(link, t = C, criterion='maxclust')\n",
    "        return clusters\n",
    "\n",
    "\n",
    "    def featImpMDA_clusterized(clf, X, y, cv, sample_weight, t1, pctEmbargo, scoring, cluster_subsets):\n",
    "        # feat importance based on OOS score reduction\n",
    "        if scoring not in ['neg_log_loss','accuracy']:\n",
    "            raise Exception('wrong scoring method.')\n",
    "\n",
    "        cvGen=PurgedKFold(n_splits=cv,t1=t1,pctEmbargo=pctEmbargo) # purged cv\n",
    "        scr0,scr1=pd.Series(),pd.DataFrame(columns=X.columns)\n",
    "\n",
    "        for i,(train,test) in enumerate(cvGen.split(X=X)):\n",
    "            X0,y0,w0=X.iloc[train,:],y.iloc[train],sample_weight.iloc[train]\n",
    "            X1,y1,w1=X.iloc[test,:],y.iloc[test],sample_weight.iloc[test]\n",
    "            fit=clf.fit(X=X0,y=y0,sample_weight=w0.values)\n",
    "            pred=fit.predict(X1)\n",
    "            scr0.loc[i]=accuracy_score(y1,pred,sample_weight=w1.values)\n",
    "            # for j in X.columns:\n",
    "            for j in cluster_subsets:\n",
    "\n",
    "                X1_=X1.copy(deep=True)\n",
    "\n",
    "                for ji in j:\n",
    "                    np.random.shuffle(X1_[ji].values) # permutation of a single column\n",
    "\n",
    "                pred=fit.predict(X1_)\n",
    "                scr1.loc[i,j]=accuracy_score(y1,pred,sample_weight=w1.values)\n",
    "\n",
    "        imp=(-scr1).add(scr0,axis=0)\n",
    "        imp=imp/(1.-scr1)\n",
    "        imp=pd.concat({'mean':imp.mean(),'std':imp.std()*imp.shape[0]**-.5},axis=1)\n",
    "        return imp,scr0.mean()\n",
    "\n",
    "    clusters = cluster_features()\n",
    "    cluster_subsets = [[f for c, f in zip(clusters, X.columns) if c == ci] for ci in range(1, C+1)]\n",
    "\n",
    "    n_jobs = -1\n",
    "    clf = DecisionTreeClassifier(criterion='entropy', \n",
    "                                 max_features=1, \n",
    "                                 class_weight='balanced', \n",
    "                                 min_weight_fraction_leaf=minWLeaf)\n",
    "    clf = BaggingClassifier(base_estimator = clf, \n",
    "                            n_estimators=n_estimators, \n",
    "                            max_features=1.,\n",
    "                            max_samples=max_samples,\n",
    "                            oob_score=True,\n",
    "                            n_jobs=n_jobs)\n",
    "    \n",
    "    fit = clf.fit(X=X,\n",
    "                  y=y,\n",
    "                  sample_weight=sample_weight.values)\n",
    "    \n",
    "    oob=fit.oob_score_\n",
    "\n",
    "    imp, oos = featImpMDA_clusterized(clf, X, y, cv, sample_weight, t1, pctEmbargo, scoring, cluster_subsets)\n",
    "\n",
    "    return imp, oob, oos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def feat_imp_PCA(X):\n",
    "    cov_mat = np.cov(X.T)\n",
    "    eig_vals, eig_vecs = np.linalg.eig(cov_mat)\n",
    "    \n",
    "    # Make a list of (eigenvalue, eigenvector) tuples\n",
    "    eig_pairs = [(np.abs(eig_vals[i]), eig_vecs[:,i]) for i in range(len(eig_vals))]\n",
    "\n",
    "    eig_pairs_importance = pd.DataFrame(\n",
    "        data = {\n",
    "            'feature': X.columns,\n",
    "            'mean': [e[0] for e in eig_pairs],\n",
    "            'std': [0] * len(eig_pairs)\n",
    "        }\n",
    "    )\n",
    "    eig_pairs_importance = eig_pairs_importance.set_index('feature')\n",
    "    return eig_pairs_importance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shap_imp(clf, X):\n",
    "    explainer = shap.TreeExplainer(clf)\n",
    "    shap_values = explainer.shap_values(X)\n",
    "\n",
    "    fi0 = np.abs(shap_values[0]).mean(axis=0)\n",
    "    fi1 = np.abs(shap_values[1]).mean(axis=0)\n",
    "    fi = fi0 + fi1\n",
    "    imp = pd.DataFrame({\n",
    "        'feature': X.columns.tolist(),\n",
    "        'mean': fi\n",
    "    })\n",
    "    imp = imp.set_index('feature')\n",
    "\n",
    "    return imp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9FKjEESG2Crm"
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection._split import _BaseKFold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gOv65AjC177M"
   },
   "outputs": [],
   "source": [
    "class PurgedKFold(_BaseKFold):\n",
    "    '''\n",
    "    Extend KFold class to work with labels that span intervals\n",
    "    The train is purged of observations overlapping test-label intervals\n",
    "    Test set is assumed contiguous (shuffle=False), w/o training samples in between\n",
    "    '''\n",
    "    def __init__(self, n_splits=3, t1=None, pctEmbargo=0.):\n",
    "        if not isinstance(t1, pd.Series):\n",
    "            raise ValueError('Label Through Dates must be a pd.Series')\n",
    "        super(PurgedKFold,self).__init__(n_splits, shuffle=False, random_state=None)\n",
    "        self.t1 = t1\n",
    "        self.pctEmbargo = pctEmbargo\n",
    "\n",
    "\n",
    "    def split(self,X,y=None,groups=None):\n",
    "        if (X.index==self.t1.index).sum()!=len(self.t1):\n",
    "            raise ValueError('X and ThruDateValues must have the same index')\n",
    "        indices = np.arange(X.shape[0])\n",
    "        mbrg = int(X.shape[0] * self.pctEmbargo)\n",
    "        test_starts=[(i[0],i[-1]+1) for i in np.array_split(np.arange(X.shape[0]), self.n_splits)]\n",
    "        for i,j in test_starts:\n",
    "            t0 = self.t1.index[i] # start of test set\n",
    "            test_indices = indices[i:j]\n",
    "            maxT1Idx = self.t1.index.searchsorted(self.t1[test_indices].max())\n",
    "            train_indices = self.t1.index.searchsorted(self.t1[self.t1<=t0].index)\n",
    "            if maxT1Idx < X.shape[0]: # right train (with embargo)\n",
    "                train_indices = np.concatenate((train_indices, indices[maxT1Idx+mbrg:]))\n",
    "            yield train_indices,test_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qPMF21G_46My"
   },
   "outputs": [],
   "source": [
    "def cvScore(clf,X,y,sample_weight,scoring='accuracy',t1=None,cv=None,cvGen=None, pctEmbargo=None):\n",
    "    if scoring not in ['neg_log_loss','accuracy']:\n",
    "        raise Exception('wrong scoring method.')\n",
    "    if cvGen is None:\n",
    "        cvGen = PurgedKFold(n_splits=cv, t1=t1, pctEmbargo=pctEmbargo) # purged\n",
    "    score=[]\n",
    "\n",
    "    for train,test in cvGen.split(X=X):\n",
    "        fit=clf.fit(X=X.iloc[train,:],y=y.iloc[train],\n",
    "        sample_weight=sample_weight.iloc[train].values)\n",
    "        pred=fit.predict(X.iloc[test,:])\n",
    "        score_=accuracy_score(y.iloc[test],pred,sample_weight=sample_weight.iloc[test].values)\n",
    "        score.append(score_)\n",
    "    return np.array(score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fYsFvpHoyup9"
   },
   "outputs": [],
   "source": [
    "def featImportance(trnsX,\n",
    "                   cont,\n",
    "                   n_estimators=1000,\n",
    "                   cv=10,\n",
    "                   max_samples=1.,\n",
    "                   numThreads=24,\n",
    "                   pctEmbargo=0,\n",
    "                   scoring='accuracy',\n",
    "                   method='SFI',\n",
    "                   minWLeaf=0.,\n",
    "                   **kargs):\n",
    "\n",
    "    n_jobs=(-1 if numThreads > 1 else 1)\n",
    "\n",
    "    clf = DecisionTreeClassifier(criterion='entropy', \n",
    "                                 max_features=1, \n",
    "                                 class_weight='balanced', \n",
    "                                 min_weight_fraction_leaf=minWLeaf)\n",
    "    clf = BaggingClassifier(base_estimator = clf, \n",
    "                            n_estimators=n_estimators, \n",
    "                            max_features=1.,\n",
    "                            max_samples=max_samples,\n",
    "                            oob_score=True,\n",
    "                            n_jobs=n_jobs)\n",
    "    \n",
    "    fit = clf.fit(X=trnsX,\n",
    "                  y=cont['bin'],\n",
    "                  sample_weight=cont['w'].values)\n",
    "    \n",
    "    oob=fit.oob_score_\n",
    "    \n",
    "    if method == 'MDI':\n",
    "        imp = featImpMDI(fit, featNames=trnsX.columns)\n",
    "        oos = cvScore(clf, \n",
    "                      X=trnsX, \n",
    "                      y=cont['bin'], \n",
    "                      cv=cv, \n",
    "                      sample_weight=cont['w'], \n",
    "                      t1 = cont['t1'],\n",
    "                      pctEmbargo=pctEmbargo,\n",
    "                      scoring=scoring).mean()\n",
    "    elif method == 'MDA':\n",
    "        imp, oos = featImpMDA(clf,\n",
    "                              X=trnsX,\n",
    "                              y=cont['bin'],\n",
    "                              cv=cv,\n",
    "                              sample_weight=cont['w'], \n",
    "                              t1 = cont['t1'], \n",
    "                              pctEmbargo=pctEmbargo, \n",
    "                              scoring=scoring)\n",
    "    elif method=='SFI':\n",
    "        cvGen=PurgedKFold(n_splits=cv,t1=cont['t1'],pctEmbargo=pctEmbargo)\n",
    "        oos=cvScore(clf,\n",
    "                    X=trnsX,\n",
    "                    y=cont['bin'],\n",
    "                    sample_weight=cont['w'],\n",
    "                    scoring=scoring,cvGen=cvGen).mean()\n",
    "        clf.n_jobs = 1\n",
    "        # imp=mpPandasObj(auxFeatImpSFI,('featNames',trnsX.columns),numThreads,\n",
    "        # clf=clf,trnsX=trnsX,cont=cont,scoring=scoring,cvGen=cvGen)\n",
    "        imp = auxFeatImpSFI(trnsX.columns, clf, trnsX, cont, scoring, cvGen)\n",
    "        \n",
    "    elif method == 'CFI':\n",
    "        C = 3\n",
    "        imp,oob,oos = feat_imp_CFI_MDA(trnsX, \n",
    "                               cont['bin'], \n",
    "                               cv, \n",
    "                               cont['w'], \n",
    "                               cont['t1'],\n",
    "                               pctEmbargo, scoring, C, minWLeaf, max_samples, n_estimators\n",
    "                               )\n",
    "        \n",
    "    elif method == 'SHAP':\n",
    "        clf = RandomForestClassifier()\n",
    "        clf.fit(X=trnsX,\n",
    "                  y=cont['bin'],\n",
    "                  sample_weight=cont['w'].values)\n",
    "\n",
    "        imp = shap_imp(clf, trnsX)\n",
    "        oos = None\n",
    "\n",
    "    elif method == 'PCA':\n",
    "        imp = feat_imp_PCA(trnsX)\n",
    "        oos = None\n",
    "        \n",
    "    return imp, oob, oos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict0={'minWLeaf': [0.],\n",
    "       'scoring': ['accuracy'],\n",
    "       'method': ['MDI','MDA','SFI','CFI','SHAP','PCA'],\n",
    "       'max_samples': [1.]}\n",
    "\n",
    "jobs, out = (dict(zip(dict0,i)) for i in product(*dict0.values())), []\n",
    "kargs = {'pathOut': './', 'n_estimators': 10, 'cv': 10}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MDI_accuracy_0.00_1.0\n",
      "{'pathOut': './', 'n_estimators': 10, 'cv': 10, 'minWLeaf': 0.0, 'scoring': 'accuracy', 'method': 'MDI', 'max_samples': 1.0, 'simNum': 'MDI_accuracy_0.00_1.0'}\n",
      "MDA_accuracy_0.00_1.0\n",
      "{'pathOut': './', 'n_estimators': 10, 'cv': 10, 'minWLeaf': 0.0, 'scoring': 'accuracy', 'method': 'MDA', 'max_samples': 1.0, 'simNum': 'MDA_accuracy_0.00_1.0'}\n",
      "SFI_accuracy_0.00_1.0\n",
      "{'pathOut': './', 'n_estimators': 10, 'cv': 10, 'minWLeaf': 0.0, 'scoring': 'accuracy', 'method': 'SFI', 'max_samples': 1.0, 'simNum': 'SFI_accuracy_0.00_1.0'}\n",
      "CFI_accuracy_0.00_1.0\n",
      "{'pathOut': './', 'n_estimators': 10, 'cv': 10, 'minWLeaf': 0.0, 'scoring': 'accuracy', 'method': 'CFI', 'max_samples': 1.0, 'simNum': 'CFI_accuracy_0.00_1.0'}\n",
      "SHAP_accuracy_0.00_1.0\n",
      "{'pathOut': './', 'n_estimators': 10, 'cv': 10, 'minWLeaf': 0.0, 'scoring': 'accuracy', 'method': 'SHAP', 'max_samples': 1.0, 'simNum': 'SHAP_accuracy_0.00_1.0'}\n",
      "PCA_accuracy_0.00_1.0\n",
      "{'pathOut': './', 'n_estimators': 10, 'cv': 10, 'minWLeaf': 0.0, 'scoring': 'accuracy', 'method': 'PCA', 'max_samples': 1.0, 'simNum': 'PCA_accuracy_0.00_1.0'}\n"
     ]
    }
   ],
   "source": [
    "importances = []\n",
    "\n",
    "for job in jobs:\n",
    "\n",
    "    job['simNum'] = job['method'] + '_' + job['scoring'] + '_' + '%.2f'%job['minWLeaf'] +  '_' + str(job['max_samples'])\n",
    "    kargs.update(job)\n",
    "    print(job['simNum'])\n",
    "    print(kargs)\n",
    "\n",
    "    imp, oob, oos=featImportance(trnsX=X, cont=Y, pctEmbargo=0.1, **kargs)\n",
    "    importances.append(imp)\n",
    "    # plotFeatImportance(imp=imp,oob=oob,oos=oos,**kargs)\n",
    "\n",
    "    df0 = imp[['mean']]/imp['mean'].abs().sum()\n",
    "    df0['type'] = df0.index #[i[0] for i in df0.index]\n",
    "    df0 = df0.groupby('type')['mean'].sum().to_dict()\n",
    "    df0.update({'oob':oob,'oos':oos})\n",
    "    df0.update(job)\n",
    "\n",
    "    out.append(df0)\n",
    "    out_csv = pd.DataFrame(out).sort_values(['method','scoring','minWLeaf','max_samples'])\n",
    "    out_csv.to_csv(kargs['pathOut'] + 'stats.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importance visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>feat_ATR_close</th>\n",
       "      <th>feat_HT_DCPERIOD_close</th>\n",
       "      <th>feat_HT_DCPHASE_close</th>\n",
       "      <th>feat_OBV_volume</th>\n",
       "      <th>feat_RSI_close</th>\n",
       "      <th>feat_autocorr_frac_close</th>\n",
       "      <th>feat_kurt_frac_close</th>\n",
       "      <th>feat_mean_frac_close</th>\n",
       "      <th>feat_random1</th>\n",
       "      <th>feat_random2</th>\n",
       "      <th>...</th>\n",
       "      <th>feat_random5</th>\n",
       "      <th>feat_skew_frac_close</th>\n",
       "      <th>feat_std_frac_close</th>\n",
       "      <th>max_samples</th>\n",
       "      <th>method</th>\n",
       "      <th>minWLeaf</th>\n",
       "      <th>oob</th>\n",
       "      <th>oos</th>\n",
       "      <th>scoring</th>\n",
       "      <th>simNum</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>7.293540e-02</td>\n",
       "      <td>7.293540e-02</td>\n",
       "      <td>7.293540e-02</td>\n",
       "      <td>7.293540e-02</td>\n",
       "      <td>7.293540e-02</td>\n",
       "      <td>7.293540e-02</td>\n",
       "      <td>7.293540e-02</td>\n",
       "      <td>0.072935</td>\n",
       "      <td>7.293540e-02</td>\n",
       "      <td>-6.912515e-03</td>\n",
       "      <td>...</td>\n",
       "      <td>7.293540e-02</td>\n",
       "      <td>7.293540e-02</td>\n",
       "      <td>0.072935</td>\n",
       "      <td>1.0</td>\n",
       "      <td>CFI</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.583152</td>\n",
       "      <td>0.528489</td>\n",
       "      <td>accuracy</td>\n",
       "      <td>CFI_accuracy_0.00_1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-1.337508e-02</td>\n",
       "      <td>2.961205e-02</td>\n",
       "      <td>-2.780746e-02</td>\n",
       "      <td>1.068063e-01</td>\n",
       "      <td>5.806998e-02</td>\n",
       "      <td>-3.442682e-02</td>\n",
       "      <td>-4.344001e-02</td>\n",
       "      <td>-0.007281</td>\n",
       "      <td>5.952835e-02</td>\n",
       "      <td>-7.389802e-02</td>\n",
       "      <td>...</td>\n",
       "      <td>-2.336262e-01</td>\n",
       "      <td>5.549487e-03</td>\n",
       "      <td>-0.190847</td>\n",
       "      <td>1.0</td>\n",
       "      <td>MDA</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.591403</td>\n",
       "      <td>0.518952</td>\n",
       "      <td>accuracy</td>\n",
       "      <td>MDA_accuracy_0.00_1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>7.559227e-02</td>\n",
       "      <td>6.770376e-02</td>\n",
       "      <td>7.443687e-02</td>\n",
       "      <td>7.397828e-02</td>\n",
       "      <td>7.459550e-02</td>\n",
       "      <td>7.375698e-02</td>\n",
       "      <td>7.432938e-02</td>\n",
       "      <td>0.080570</td>\n",
       "      <td>7.161460e-02</td>\n",
       "      <td>7.519755e-02</td>\n",
       "      <td>...</td>\n",
       "      <td>7.414210e-02</td>\n",
       "      <td>7.183121e-02</td>\n",
       "      <td>0.071762</td>\n",
       "      <td>1.0</td>\n",
       "      <td>MDI</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.592271</td>\n",
       "      <td>0.531092</td>\n",
       "      <td>accuracy</td>\n",
       "      <td>MDI_accuracy_0.00_1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1.476454e-20</td>\n",
       "      <td>1.354210e-20</td>\n",
       "      <td>6.143694e-21</td>\n",
       "      <td>2.672941e-20</td>\n",
       "      <td>4.495837e-20</td>\n",
       "      <td>4.036255e-19</td>\n",
       "      <td>1.994035e-18</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>3.511899e-21</td>\n",
       "      <td>1.153422e-21</td>\n",
       "      <td>...</td>\n",
       "      <td>3.189853e-23</td>\n",
       "      <td>1.234664e-16</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>PCA</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.586192</td>\n",
       "      <td>NaN</td>\n",
       "      <td>accuracy</td>\n",
       "      <td>PCA_accuracy_0.00_1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>6.816177e-02</td>\n",
       "      <td>6.638226e-02</td>\n",
       "      <td>6.620833e-02</td>\n",
       "      <td>6.700590e-02</td>\n",
       "      <td>6.666725e-02</td>\n",
       "      <td>6.850018e-02</td>\n",
       "      <td>6.684142e-02</td>\n",
       "      <td>0.070909</td>\n",
       "      <td>6.695224e-02</td>\n",
       "      <td>6.672390e-02</td>\n",
       "      <td>...</td>\n",
       "      <td>6.712492e-02</td>\n",
       "      <td>6.695248e-02</td>\n",
       "      <td>0.064662</td>\n",
       "      <td>1.0</td>\n",
       "      <td>SFI</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.590100</td>\n",
       "      <td>0.516350</td>\n",
       "      <td>accuracy</td>\n",
       "      <td>SFI_accuracy_0.00_1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>9.281508e-02</td>\n",
       "      <td>6.687206e-02</td>\n",
       "      <td>7.658337e-02</td>\n",
       "      <td>1.248265e-01</td>\n",
       "      <td>6.585172e-02</td>\n",
       "      <td>6.484937e-02</td>\n",
       "      <td>7.695916e-02</td>\n",
       "      <td>0.121948</td>\n",
       "      <td>5.076410e-02</td>\n",
       "      <td>4.308980e-02</td>\n",
       "      <td>...</td>\n",
       "      <td>4.700593e-02</td>\n",
       "      <td>6.233050e-02</td>\n",
       "      <td>0.079034</td>\n",
       "      <td>1.0</td>\n",
       "      <td>SHAP</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.590968</td>\n",
       "      <td>NaN</td>\n",
       "      <td>accuracy</td>\n",
       "      <td>SHAP_accuracy_0.00_1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>6 rows × 22 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   feat_ATR_close  feat_HT_DCPERIOD_close  feat_HT_DCPHASE_close  \\\n",
       "3    7.293540e-02            7.293540e-02           7.293540e-02   \n",
       "1   -1.337508e-02            2.961205e-02          -2.780746e-02   \n",
       "0    7.559227e-02            6.770376e-02           7.443687e-02   \n",
       "5    1.476454e-20            1.354210e-20           6.143694e-21   \n",
       "2    6.816177e-02            6.638226e-02           6.620833e-02   \n",
       "4    9.281508e-02            6.687206e-02           7.658337e-02   \n",
       "\n",
       "   feat_OBV_volume  feat_RSI_close  feat_autocorr_frac_close  \\\n",
       "3     7.293540e-02    7.293540e-02              7.293540e-02   \n",
       "1     1.068063e-01    5.806998e-02             -3.442682e-02   \n",
       "0     7.397828e-02    7.459550e-02              7.375698e-02   \n",
       "5     2.672941e-20    4.495837e-20              4.036255e-19   \n",
       "2     6.700590e-02    6.666725e-02              6.850018e-02   \n",
       "4     1.248265e-01    6.585172e-02              6.484937e-02   \n",
       "\n",
       "   feat_kurt_frac_close  feat_mean_frac_close  feat_random1  feat_random2  \\\n",
       "3          7.293540e-02              0.072935  7.293540e-02 -6.912515e-03   \n",
       "1         -4.344001e-02             -0.007281  5.952835e-02 -7.389802e-02   \n",
       "0          7.432938e-02              0.080570  7.161460e-02  7.519755e-02   \n",
       "5          1.994035e-18              0.000000  3.511899e-21  1.153422e-21   \n",
       "2          6.684142e-02              0.070909  6.695224e-02  6.672390e-02   \n",
       "4          7.695916e-02              0.121948  5.076410e-02  4.308980e-02   \n",
       "\n",
       "            ...            feat_random5  feat_skew_frac_close  \\\n",
       "3           ...            7.293540e-02          7.293540e-02   \n",
       "1           ...           -2.336262e-01          5.549487e-03   \n",
       "0           ...            7.414210e-02          7.183121e-02   \n",
       "5           ...            3.189853e-23          1.234664e-16   \n",
       "2           ...            6.712492e-02          6.695248e-02   \n",
       "4           ...            4.700593e-02          6.233050e-02   \n",
       "\n",
       "   feat_std_frac_close  max_samples  method  minWLeaf       oob       oos  \\\n",
       "3             0.072935          1.0     CFI       0.0  0.583152  0.528489   \n",
       "1            -0.190847          1.0     MDA       0.0  0.591403  0.518952   \n",
       "0             0.071762          1.0     MDI       0.0  0.592271  0.531092   \n",
       "5             1.000000          1.0     PCA       0.0  0.586192       NaN   \n",
       "2             0.064662          1.0     SFI       0.0  0.590100  0.516350   \n",
       "4             0.079034          1.0    SHAP       0.0  0.590968       NaN   \n",
       "\n",
       "    scoring                  simNum  \n",
       "3  accuracy   CFI_accuracy_0.00_1.0  \n",
       "1  accuracy   MDA_accuracy_0.00_1.0  \n",
       "0  accuracy   MDI_accuracy_0.00_1.0  \n",
       "5  accuracy   PCA_accuracy_0.00_1.0  \n",
       "2  accuracy   SFI_accuracy_0.00_1.0  \n",
       "4  accuracy  SHAP_accuracy_0.00_1.0  \n",
       "\n",
       "[6 rows x 22 columns]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "out_csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MDI\n",
      "MDA\n",
      "SFI\n",
      "CFI\n",
      "SHAP\n",
      "PCA\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for name_i, importance_i in zip(dict0['method'], importances):\n",
    "    print(name_i)\n",
    "    importance_i.sort_values('mean').plot.barh()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import weightedtau"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "WeightedTauResult(correlation=-0.10789805716617751, pvalue=nan)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weightedtau(importances[4]['mean'].values, importances[-1]['mean'].values**-1.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# OOS evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "CUSTOM_IMPORTANT_FEATURES = [\n",
    "    'feat_mean_frac_close', \n",
    "    'feat_OBV_volume', \n",
    "    'feat_kurt_frac_close', \n",
    "    'feat_ATR_close', \n",
    "    'feat_std_frac_close', \n",
    "    'feat_HT_DCPERIOD_close'\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import log_loss, f1_score, matthews_corrcoef, roc_auc_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cvScore2(clf,X,y,sample_weight,t1=None,cv=None,cvGen=None, pctEmbargo=None):\n",
    "\n",
    "    if cvGen is None:\n",
    "        cvGen = PurgedKFold(n_splits=cv, t1=t1, pctEmbargo=pctEmbargo) # purged\n",
    "        \n",
    "    scores_f1, scores_mmc, scores_corr = [], [], []\n",
    "\n",
    "    for train,test in cvGen.split(X=X):\n",
    "        \n",
    "        fit=clf.fit(X=X.iloc[train,:],y=y.iloc[train],\n",
    "        sample_weight=sample_weight.iloc[train].values)\n",
    "        \n",
    "        pred = fit.predict(X.iloc[test,:])\n",
    "        pred_p = fit.predict_proba(X.iloc[test,:])\n",
    "        \n",
    "        score_f1 = f1_score(y.iloc[test],pred,sample_weight=sample_weight.iloc[test].values)\n",
    "        score_mmc = matthews_corrcoef(y.iloc[test],pred,sample_weight=sample_weight.iloc[test].values)\n",
    "        score_corr = roc_auc_score(y.iloc[test],\n",
    "                                    pred_p[:, 1],)\n",
    "        \n",
    "        scores_f1.append(score_f1)\n",
    "        scores_mmc.append(score_mmc)\n",
    "        scores_corr.append(score_corr)\n",
    "        \n",
    "    return np.array(scores_f1), np.array(scores_mmc), np.array(scores_corr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "res_all_f1, res_all_mmc, res_all_corr = [], [], []\n",
    "res_normal_f1, res_normal_mmc, res_normal_corr = [], [], []\n",
    "\n",
    "for i in range(100):\n",
    "    lr = RandomForestClassifier()\n",
    "    scores_f1, scores_mmc, scores_corr = cvScore2(lr, \n",
    "                     X_oos, \n",
    "                     Y_oos['bin'], Y_oos['w'], \n",
    "                     Y_oos['t1'], \n",
    "                     5, None, 0.05)\n",
    "    res_all_f1.append(np.mean(scores_f1))\n",
    "    res_all_mmc.append(np.mean(scores_mmc))\n",
    "    res_all_corr.append(np.mean(scores_corr))\n",
    "\n",
    "    lr = RandomForestClassifier()\n",
    "    scores_f1, scores_mmc, scores_corr = cvScore2(lr, \n",
    "                     X_oos[CUSTOM_IMPORTANT_FEATURES], \n",
    "                     Y_oos['bin'], Y_oos['w'], \n",
    "                     Y_oos['t1'], \n",
    "                     5, None, 0.05)\n",
    "    res_normal_f1.append(np.mean(scores_f1))\n",
    "    res_normal_mmc.append(np.mean(scores_mmc))\n",
    "    res_normal_corr.append(np.mean(scores_corr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.hist(res_all_f1, alpha = 0.25, label = 'F1 score all features')\n",
    "plt.hist(res_normal_f1, alpha = 0.25, label = 'F1 score selected features')\n",
    "plt.axvline(np.mean(res_all_f1), color = 'blue', ls = '--')\n",
    "plt.axvline(np.mean(res_normal_f1), color = 'orange', ls = '--')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "plt.figure()\n",
    "plt.hist(res_all_mmc, alpha = 0.25, label = 'MMC score all features')\n",
    "plt.hist(res_normal_mmc, alpha = 0.25, label = 'MMC score selected features')\n",
    "plt.axvline(np.mean(res_all_mmc), color = 'blue', ls = '--')\n",
    "plt.axvline(np.mean(res_normal_mmc), color = 'orange', ls = '--')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "plt.figure()\n",
    "plt.hist(res_all_corr, alpha = 0.25, label = 'ROC-AUC score all features')\n",
    "plt.hist(res_normal_corr, alpha = 0.25, label = 'ROC-AUC score selected features')\n",
    "plt.axvline(np.mean(res_all_corr), color = 'blue', ls = '--')\n",
    "plt.axvline(np.mean(res_normal_corr), color = 'orange', ls = '--')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
